package writtenTraining.day48;

import java.util.*;


/**
 * day48(1):模拟：疯狂的自我检索者
 */

public class Main {
    public static void main(String[] args) {
//         模拟 
//         输入
        Scanner in =new  Scanner(System.in);
        int n = in.nextInt(), k = in.nextInt();
        
        int t = n - k ;
        int ret = 0;
        while(t-- > 0) {
            ret += in.nextInt();
        }
        
        double max = ret + 0.0;
        for(int i =0; i < k; i++) {
            max += 5.0;
        }
        
        
        double min = ret + 0.0;
        for(int i =0; i < k; i++) {
            min += 1.0;
        }
        
        System.out.printf("%.5f " , min / n);
        System.out.printf("%.5f\n",max / n);
        
    }
}


/**
 * day48(2):前缀和 + 栈:NC115 栈和排序
 */

 class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 栈排序
     * @param a int整型一维数组 描述入栈顺序
     * @return int整型一维数组
     */
    public int[] solve (int[] a) {
        // 前缀和 + 栈
        int n = a.length;
        int[] dp = new int[n + 1];

        // 前缀和预处理
        for(int i = n - 1; i >= 0 ; i--) {
            dp[i] = Math.max(dp[i+1],a[i]);
        }

        int[] ret = new int[n];
        int pos = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i =  0; i < n;) {
            stack.push(a[i]);
            i++;
            // 跳到下一位
            while(!stack.isEmpty() && stack.peek() >= dp[i]) {
                // 出当前最大的元素
                ret[pos++] = stack.pop();
            }
        }

        // 取出栈最后的元素
        while(!stack.isEmpty()) {
            ret[pos++] = stack.pop();
        }

        return ret;
    }
}


/**
 * day(2)哈希 + 栈：NC115 栈和排序
 */


 class Solution2 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 栈排序
     * @param a int整型一维数组 描述入栈顺序
     * @return int整型一维数组
     */
    public int[] solve (int[] a) {
        // 哈希 + 栈
        int n = a.length;
        int[] dp = new int[n + 1];

        // 进行前缀和
        boolean[] vim = new boolean[n + 1];
        int max = n;

        int[] ret = new int[n];
        int pos = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i = 0 ; i < n; i++) {
            stack.add(a[i]);
            vim[a[i]] = true;

            while(vim[max]) {
                max--;
            }

            while(!stack.isEmpty() && stack.peek() >= max) {
                ret[pos++] =  stack.peek();
                stack.pop();
            }

        }

        return ret;
    }
}

/**
 * day48(3):排序 + 贪心 + 前缀和 + 滑动窗口:加减
 */



class Main2 {
    public static void main(String[] args) {
//         排序 + 贪心 + 前缀和 + 滑动窗口
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long k = in.nextLong();

        long[] nums = new long[n];

        for(int i = 0; i < n ; i++) {
            nums[i] = in.nextLong();
        }

//         排序
        Arrays.sort(nums);


//         前缀和
        long[] dp = new long[n+1];
        for(int i = 1; i <= n ; i++) {
            dp[i] = dp[i-1] + nums[i-1];
        }

        long ret = -0x3f3f3f3f3f3f3f3fL;
//         滑动窗口
        for(int left = 0, right = 0 ; right < n ; right++) {
            // 入窗口
            int mid = left + (right - left) / 2;
            long cost = (mid - left) * nums[mid] - (dp[mid + 1] - dp[left])
                    + (dp[right + 1] - dp[mid]) - (right - mid) * nums[mid];

//             出窗口
            while(cost > k) {
                left++;
                mid = left + (right - left) / 2;
                cost = (mid - left) * nums[mid] - (dp[mid + 1] - dp[left])
                        + (dp[right + 1] - dp[mid]) - (right - mid) * nums[mid];

            }


//            更新结果
            ret = Math.max(right - left + 1, ret);
        }

        System.out.println(ret);
    }
}